
import { newArrayObserve } from './array'

class Observer {
    constructor(data) {
        Object.defineProperty(data, '__ob__', { //新增一个__ob__ 进行标识，但是必须要不可枚举，否则死循环
            value: this,
            enumerable: false
        })
        // data.__ob__ = this; //通过defineProperty设置成不可枚举
        if(Array.isArray(data)) { // 数组 重写数组的7个方法，并且对数组的每项进行数据劫持
            data.__proto__ = newArrayObserve
            this.observeArray(data)
        } else {
            this.walk(data)
        }
    }
    walk(data) {
        Object.keys(data).forEach(key => defineReactive(data, key, data[key]))
    }
    observeArray(data) {
        data.forEach(item => observe(item))
    }
}

export function defineReactive(target, key, value) { //这里使用了闭包，相当于get和set可以使用value；
    observe(value); //递归判断是否嵌套对象
    Object.defineProperty(target, key, {
        get() {
            console.log('取值了');
            return value
        },
        set(newValue) {
            console.log('设置值了...');
            if(newValue === value) return;
            observe(newValue)
            value = newValue;
        }
    })
}

export function observe (data) {
    if(data.__ob__ instanceof Observer) {
        return data.__ob__;
    }

    if(typeof data  !== "object" || data == null) return;

    return new Observer(data);

}